COMMENT ⊗   VALID 00008 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	BEGIN "SETUP"
C00006 00003	BEGIN
C00008 00004	PROC PLACE
C00009 00005	INTEGER PROC WRITE(STRING FILE)
C00011 00006	PROC DUMP
C00013 00007	PROC DSKLOC(STRING IFILE,OFILE)
C00014 00008	OUTSTR("WHICH TABLES DO YOU WANT CONSTRUCTED?" ↓)
C00016 ENDMK
C⊗;
BEGIN "SETUP"

REQUIRE "IODEFS.SAI[SEC,RCP]" SOURCE_FILE;

DEFINE MAXLEN= "10";
LABEL EXIT;
INTEGER J,P,VAL,TOTAL,SUBTOT;
BOOLEAN TRACE;
PRELOAD_WITH [5]FALSE;
BOOLEAN ARRAY TASK[1:5];
STRING S,T,F,V;
STRING SYNINP,SYNOUT,SPTINP,SPTOUT,CPTINP,CPTOUT,EXCOUT,DLKINP,DLKOUT;
PRELOAD_WITH 2000,3000,2000,1500,500,400,100,100,10,10;
INTEGER ARRAY LEN[1:MAXLEN];
INTEGER ARRAY COUNT[1:MAXLEN],PATTERN[1:MAXLEN];

TOTAL← 0;
OUTSTR("THE CURRENT PATTERN TABLE ALLOCATIONS ARE THE FOLLOWING:" ↓);
FOR I← 1 TIL MAXLEN DO
	OUTSTR("(" & CVS(I) & ")" ∂ CVS(LEN[I]) ∂ " ");
OUTSTR(NULL ↓ ↓ & "TYPE RETURN TO LEAVE THEM THIS WAY." ↓);
OUTSTR("OTHERWISE, TYPE <TABLE NUMBER><SPACE><NEW ALLOCATION><CARRIAGE-RETURN>" ↓);
OUTSTR("FOR EACH ONE YOU WISH TO CHANGE. TERMINATE WITH A CARRIAGE-RETURN." ↓);
WHILE (S ← GET_A_STRING(NULL)) DO LEN[INTSCAN(S,BRK)] ← INTSCAN(S,BRK);

SYNINP← "SYNONM.ALF[PAR,RCP]"; SYNOUT← "SYNONM.PAR[PAR,RCP]";
SPTINP← "SPATS.SEL[PAR,RCP]"; SPTOUT← "SPATS.PAR[PAR,RCP]";
CPTINP← "CPATS.SEL[PAR,RCP]"; CPTOUT← "CPATS.PAR[PAR,RCP]";
EXCOUT← "SETUP.ERR";
DLKINP← "PDATX[PAR,BLF]"; DLKOUT← "PDATX.PAR[PAR,BLF]";

OUTSTR("THE FOLLOWING FILES ARE DEFAULT:" ↓);
OUTSTR("	SYNONYMS: INPUT=" ∂ SYNINP & ", OUTPUT=" ∂ SYNOUT ↓);
OUTSTR("	S-PATS:   INPUT=" ∂ SPTINP & ", OUTPUT=" ∂ SPTOUT ↓);
OUTSTR("	C-PATS:   INPUT=" ∂ CPTINP & ", OUTPUT=" ∂ CPTOUT ↓);
OUTSTR("	DSKLOCS:  INPUT=" ∂ DLKINP & ", OUTPUT=" ∂ DLKOUT ↓);
OUTSTR("	EXCEPTIONS FILE:" ∂ EXCOUT ↓ ↓);

OUTSTR("TYPE CARRIAGE-RETURN IF THESE ARE DESIRED." ↓);
OUTSTR("OTHERWISE, TYPE <ONE OF SYI,SYO,SPI,SPO,CPI,CPO,DLI,DLO,EXC><SPACE><NEW FILE>" ↓);
OUTSTR("TO CHANGE THEM. TYPE <CARRIAGE-RETURN> TO STOP." ↓);
SETBREAK(1," ",NULL,"INS");
WHILE (S ← GET_A_STRING(NULL)) DO
	BEGIN
	S← S & " "; F← SCAN(S,1,BRK); V← SCAN(S,1,BRK);
	IF EQU(F,"SYI") THEN SYNINP← V
	ELSE IF EQU(F,"SYO") THEN SYNOUT← V
	ELSE IF EQU(F,"SPI") THEN SPTINP← V
	ELSE IF EQU(F,"SPO") THEN SPTOUT← V
	ELSE IF EQU(F,"CPI") THEN CPTINP← V
	ELSE IF EQU(F,"CPO") THEN CPTOUT← V
	ELSE IF EQU(F,"DLI") THEN DLKINP← V
	ELSE IF EQU(F,"DLO") THEN DLKOUT← V
	ELSE IF EQU(F,"EXC") THEN EXCOUT← V
	END;

OUTSTR("THE TABLES ARE ASSUMED TO BE SORTED BY ASCII ORDERING." ↓);
BEGIN
INTEGER ARRAY P1[1:LEN[1],0:1],
	      P2[1:LEN[2],0:2],
	      P3[1:LEN[3],0:3],
	      P4[1:LEN[4],0:4],
	      P5[1:LEN[5],0:5],
	      P6[1:LEN[6],0:6],
	      P7[1:LEN[7],0:7],
	      P8[1:LEN[8],0:8],
	      P9[1:LEN[9],0:9],
	      P10[1:LEN[10],0:10];

PROC CLEAR;
	BEGIN
	INTEGER I;
	FOR I ← 1 TIL MAXLEN DO COUNT[I]← 0
	END;

PROC EXCEP(STRING X);
	BEGIN
	IF TRACE THEN
		BEGIN
		OUTSTR("			***EXCEPTION*** " ↓);
		OUTSTR("			" & X ↓);
		END;
	OUT_LINE(X)
	END;

PROC OVFL;
	BEGIN
	OUTSTR("TABLE" ∂ CVS(P) ∂ "HAS OVERFLOWED. RAISE ITS ALLOCATION!" ↓);
	GOTO EXIT
	END;

PROC PUT(INTEGER ARRAY A);
	BEGIN
	INTEGER I,N;
	N ← COUNT[P]+1;
	IF N > LEN[P] THEN OVFL
	ELSE FOR I← 1 TIL P DO
		A[N,I]← PATTERN[I];
	A[N,0]← VAL;
	COUNT[P]← N
	END;
PROC PLACE;
	CASE P-1 OF
		BEGIN
		PUT(P1);
		PUT(P2);
		PUT(P3);
		PUT(P4);
		PUT(P5);
		PUT(P6);
		PUT(P7);
		PUT(P8);
		PUT(P9);
		PUT(P10)
		END;

PROC SPLITUP(STRING X);
	BEGIN
	INTEGER I,L;
	P ← 0;
	L ← LENGTH(X);
	IF L ≤ MAXLEN*5 THEN FOR I← 1 STEP 5 UNTIL L DO
		PATTERN[(P ← P+1)]← CVASC(X[I FOR 5]);
	END;

PROC GATHER;
	BEGIN
	STRING U;
	P ← 0;
	DO	BEGIN
		U ← SCAN(S,6,BRK);
		P ← P+1;
		IF P > MAXLEN THEN BEGIN P←0; BRK← ")" END
		ELSE PATTERN[P]← CVASC(U)
		END
	UNTIL BRK = ")"
	END;
INTEGER PROC WRITE(STRING FILE);
	BEGIN
	INTEGER AD,I;
	INTEGER ARRAY ADR[0:127];

INTEGER PROC WR(INTEGER ARRAY A);
	BEGIN
	INTEGER VAD,J,K;
	VAD← AD+COUNT[I]*I+1;
	VAD← VAD LOR (COUNT[I] LSH 18);
	WORDOUT(OUCH2,VAD);
	FOR K← 1 TIL I DO
		FOR J← 1 TIL COUNT[I] DO WORDOUT(OUCH2,A[J,K]);
	WORDOUT(OUCH2,0);
	FOR J← 1 TIL COUNT[I] DO WORDOUT(OUCH2,A[J,0]);
	RETURN(COUNT[I]*(I+1)+2)
	END;

	ENTER(OUCH2,FILE,FLAG);

	FOR I← 0 TIL 127 DO ADR[I]← 0;
	AD← 1;
	FOR I← 1 TIL MAXLEN DO
		IF COUNT[I] > 0 THEN
			BEGIN
			ADR[I]← AD;
			AD← AD + COUNT[I]*(I+1)+2
			END
		ELSE ADR[I]← 0;
	ADR[MAXLEN+1]← AD;
	ARRYOUT(OUCH2,ADR[0],128);
	AD← 1;
	WORDOUT(OUCH2,0);
	FOR I← 1 TIL MAXLEN DO
		IF COUNT[I] > 0 THEN AD← AD + (CASE I-1 OF
				(WR(P1), WR(P2), WR(P3), WR(P4), WR(P5),
				WR(P6), WR(P7), WR(P8), WR(P9), WR(P10)));
	CLOSE(OUCH2);
	RETURN(ADR[MAXLEN+1])
	END;
PROC DUMP;
	BEGIN
	INTEGER I;
	OUTSTR("(");
	FOR I ← 1 TIL P DO
		OUTSTR(CVSTR(PATTERN[I]) & " ");
	OUTSTR(") →" ∂ CVSTR(VAL) ↓);
	END;

PROC TABLES(STRING IFILE,OFILE; BOOLEAN MODE);
	BEGIN
	INTEGER CH;
	CLEAR;
	FILIN(IFILE, CH);
	BREAK_LINE;
	BREAK_BLANK;
	SETBREAK(3,"(",NULL,"INA");
	SETBREAK(4,")","(","INS");
	SETBREAK(5," )",NULL,"INS");
	SETBREAK(6," )","(","INS");	α THIS TABLE USED BY GATHER;

	OUTSTR("READING FROM FILE" ∂ IFILE ↓ ↓);
	WHILE INPUT(CH,3) DO
		BEGIN
		S← T← INPUT(CH,1);
		IF MODE THEN SPLITUP(SCAN(S,2,BRK))
		ELSE BEGIN GATHER; SCAN(S,2,BRK) END;
		VAL← CVASC(SCAN(S,5,BRK)[1 FOR 5]);
		IF (BRK = " " ∧ MODE) ∨ P = 0	THEN EXCEP("(" & T)
		ELSE	BEGIN
			PLACE;
			IF TRACE THEN DUMP
			END;
		END;
	SUBTOT← WRITE(OFILE);
	TOTAL← TOTAL+SUBTOT;
	OUTSTR("END OF FILE" ∂ IFILE ↓);
	OUTSTR(OFILE ∂ "TABLES OCCUPY" ∂ CVS(SUBTOT) ∂ "WORDS." ↓)
	END;
PROC DSKLOC(STRING IFILE,OFILE);
	BEGIN
	INTEGER CH,I;
	CLEAR;
	FILIN(IFILE, CH);
	SETBREAK(1,"(",NULL,"INA");
	SETBREAK(2, "." & LF, CR & " )", "INS");

	OUTSTR("READING FROM FILE" ∂ IFILE ↓ ↓);
	P ← 1;
	WHILE INPUT(CH,1) DO
		BEGIN
		PATTERN[1]← CVASC(INPUT(CH,2));
		S← INPUT(CH,2);
		VAL← 0;
		FOR I← 1 TIL LENGTH(S) DO VAL← (VAL LSH 3)+S[I FOR 1]-"0";
		PLACE;
		IF TRACE THEN OUTSTR("(" & CVSTR(PATTERN[1]) ∂ "." ∂ S & ")" ↓)
		END;
	OUTSTR("END OF FILE" ∂ IFILE ↓);
	SUBTOT← WRITE(OFILE);
	TOTAL← TOTAL+SUBTOT;
	OUTSTR(OFILE ∂ "TABLES OCCUPY" ∂ CVS(SUBTOT) ∂ "WORDS." ↓)
	END;
OUTSTR("WHICH TABLES DO YOU WANT CONSTRUCTED?" ↓);
OUTSTR("(<CARRIAGE RETURN> FOR ALL, OR SOME COMBINATION OF NUMBERS:" ↓);
S ← GET_A_STRING(" 1 FOR SYNONYMS, 2 FOR SPATS, 3 FOR CPATS, 4 FOR DSKLOCS)");
IF S = NULL THEN TASK[5]← TRUE ELSE
FOR I← 1 TIL LENGTH(S) DO
	BEGIN J← S[I FOR 1]-"0";
	      IF J≤4 ∧ J≥1 THEN TASK[J]← TRUE
	END;
S ← GET_A_STRING("DO YOU WANT TO WATCH THE INPUT AS IT IS READ");
TRACE ← (S = "Y");

OPEN(OUCH2,"DSK",'10,0,2,0,0,EOF);
FILOUT(EXCOUT, OUCH1);

IF TASK[5]∨TASK[1] THEN TABLES(SYNINP,SYNOUT,TRUE);
IF TASK[5]∨TASK[2] THEN TABLES(SPTINP,SPTOUT,FALSE);
IF TASK[5]∨TASK[3] THEN TABLES(CPTINP,CPTOUT,FALSE);
IF TASK[5]∨TASK[4] THEN DSKLOC(DLKINP,DLKOUT);

RELEASE(OUCH2); RELEASE(OUCH1);

OUTSTR(NULL ↓ ↓ & "TOTAL TABLE SPACE REQUIREMENT IS" ∂ CVS(TOTAL) ∂ "WORDS." ↓);
OUTSTR("THIS IS" ∂ CVOS(TOTAL) ∂ "OCTAL." ↓ ↓);
OUTSTR("EXCEPTIONS HAVE BEEN RECORDED ON FILE" ∂ EXCOUT ↓);

END;
EXIT:;
END